package main
import "fmt"
//import "strconv"
//import "unsafe"
//整型
/* func main(){
	//定义一个整数类型：
	var num1 int8 = 23
	fmt.Println(num1)
	var num2 uint8 = 20
	fmt.Println(num2)
	var num3 = 28
	//Printf函数的作用是：格式化的，把num3的类型填充到%T的位置上
	fmt.Printf("num3的类型是:%T",num3) //num3的类型是：int
	fmt.Println(unsafe.Sizeof(num3))
}
 */
//浮点型
/*  func main(){
	//定义浮点类型的数据
	var num1 float32 = 3.14
	fmt.Println(num1)
	//可以表示正/负浮点数
	var num2 float32 = -3.14
	fmt.Println(num2)
	//可以用十进制表示 / 科学计数法表示 e/E 
	var num3 float32 = 314e-2
	fmt.Println(num3)
	var num4 float32 = 314e+2
	fmt.Println(num4)
	var num5 float32 = 314e+2
	fmt.Println(num5)
	var num6 float64 = 314e-2
	fmt.Println(num6)
	//浮点数可能会有精度的损失，通常情况下建议使用float64
	var num7 float32 = 256.000000777
	fmt.Println(num7)
	var num8 float64 = 256.000000777
	fmt.Println(num8)
    //golang中默认的浮点类型：float64
	var num9 = 123.4
	fmt.Printf("num9对应的类型是:%T",num9) //float64
 } */

 //字符型
 /* func main(){
	var c1 byte = 'a' //97
	fmt.Println(c1)
	var c2 byte = '6' //54
	fmt.Println(c2)
	var c3 byte = '!' //33
	fmt.Println(c3)  
	var c4 byte = '!'
	fmt.Println(c4+12) //45
	//字符类型，本质上是一个整数，可以直接参与运算，会将对应的码值进行输出
	//ASCII码值
	var c6 byte = 'A'
	fmt.Printf("c6对应的具体字符为:%c",c6)
	//想输出对应的字符，要采用格式化输出
	fmt.Println() //换行
	//var c5 byte = '中'
	var c5 int = '中'
	fmt.Println(c5)
	//汉字字符，底层对应Unicode码值
	//对应码值为20013，byte类型溢出，可使用int
	//Golang的字符对应使用的时是UTF-8编码
	//Unicode是对应的字符集，UTF-8是Unicode的其中的一种编码方案

 } */

 //转义字符
/*  func main(){
	//\n换行
	fmt.Println("aaa\nbbb")
	//\b退格
	fmt.Println("aaa\bbbb")
	//\r - 光标回到本行开头，后续输入会替代原有字符
	fmt.Println("aaaaa\rbb")
	//\t 制表符 - 补全8位
	fmt.Println("aaaaaaaaaaa")
	fmt.Println("aaa\tbbb")
	fmt.Println("aaaaa\tbbb")
	//\"
	fmt.Println("\"Golang\"")
 }
 */

 //布尔bool类型 true/false
/*  func main(){
	//测试布尔类型的数值：
	var flag01 bool = true
	fmt.Println(flag01) //true
	var flag02 bool = false
	fmt.Println(flag02) //false
	var flag03 bool = 1 < 3
	fmt.Println(flag03) //true
 } */

 //字符串类型
//func main(){
/* 	//1.定义一个字符串：
	var s1 string = "咩Golang"
	fmt.Println(s1)

	//2.字符串不可变：指的是字符串一旦定义好，其中字符的值不能进行改变
	var s2 string = "abc"+"def"
	//s2 = "Aaa" - ok
	//s2[0]= "A" - err
	fmt.Println(s2)

	//3.字符串的表现形式：
	//(1)如果字符串中没有特殊字符，字符串的表现形式用双引号
	var s3 string = "sfadfgeweasdf"
	fmt.Println(s3)
	//(2)含有特殊字符，字符表现形式用反引号``
	var s4 string = `
	func main(){
		//1.定义一个字符串：
		var s1 string = "咩Golang"
		fmt.Println(s1)`
	fmt.Println(s4)

	//4.字符串的拼接效果
	var s5 string = "abc"+"def"
	s5+="hjk"
	fmt.Println(s5)
	//当一个字符串过长时:注意 + 保留在上一行行末
	var s6 string = "abc" + "def" + "jkl" + "def" + "jkl" + 
	"def" + "jkl" + "def" + "jkl" + 
	"def" + "jkl" + "def" + "jkl" + "def" + 
	"jkl" + "def" + "jkl"
	fmt.Println(s6)
 } */

 //默认值
/*  func main(){
	var a int      //0
	var b float32  //0
	var c float64  //0
	var d bool     //false
	var e string   //"" - 空
	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
	fmt.Println(d)
	fmt.Println(e)
 }
 */

 //显式转换T(v) - 将v转换为类型T
/*  func main(){
	var n1 int = 100
	fmt.Println(n1)
	//var n2 float32 = n1 -err
	var n2 float32 = float32(n1)
	fmt.Println(n2)
	fmt.Printf("%T",n1) //int
	fmt.Println()

	var n3 int64 = 888888
	var n4 int8 =int8(n3) // 56
	fmt.Println(n4)
	//int64 转为 int8 编译未报错，但会造成数据的溢出

	var n5 int32 = 12
	var n6 int64 = int64(n5) + 30 // = 左右类型一定要匹配
	fmt.Println(n6)

	var n7 int64 = 12
	var n8 int8 = int8(n7) + 127 //编译通过，但结果可能会溢出 - -117
	//var n9 int8 = int8(n7) + 128 //编译无法通过
	fmt.Println(n8)
	//fmt.Println(n9)
 } */

 //基本类型转string类型
 //1.fmt.Sprintf("%参数",表达式) -- 推荐
/*  func main(){
	var n1 int = 19
	var s1 string = fmt.Sprintf("%d",n1)
	fmt.Printf("s1对应的类型是:%T ,s1=%q \n",s1,s1)

	var n2 float32 = 4.78
	var s2 string = fmt.Sprintf("%f",n2)
	fmt.Printf("s2对应的类型是:%T ,s2=%q \n",s2,s2)

	var n3 bool = false
	var s3 string = fmt.Sprintf("%t",n3)
	fmt.Printf("s3对应的类型是:%T ,s3=%q \n",s3,s3)

	var n4 byte = 'a'
	var s4 string = fmt.Sprintf("%c",n4)
	fmt.Printf("s4对应的类型是:%T ,s4=%q \n",s4,s4)
 } */

 //方法2：使用strconv包的函数
/*  func main(){
	var n1 int = 18
	var s1 string = strconv.FormatInt(int64(n1),10)
	//参数：1.必须转为int64类型;2.指定字面值的进制形式为十进制
	fmt.Printf("s1对应的类型是:%T ,s1=%q\n",s1,s1)

	var n2 float64 = 4.29
	var s2 string = strconv.FormatFloat(n2,'f',9,64)
	//参数：1.本人 2.'f'(-ddd.dddd) 3.9 保留小数点后9位 4.表示此数为float64类型
    fmt.Printf("s2对应的类型是:%T ,s2=%q \n",s2,s2)

	var n3 bool = true
	var s3 string = strconv.FormatBool(n3)
	fmt.Printf("s3对应的类型是:%T ,s3=%q\n",s3,s3)
 } */

 //string类型转换为基本类型
/*  func main(){
	//string --> bool
	var s1 string = "true"
	var b bool
	//ParseBool这个函数的返回值有两个：(value bool,err error)
	//value是得到的布尔类型的数据,err出现的错误
	//只关注得到布尔类型的数据,err可以用_直接忽略
	b,_=strconv.ParseBool(s1)
	fmt.Printf("b的类型是:%T,b=%v \n",b,b)

	//string --> int64
	var s2 string = "19"
	var num1 int64
	num1,_ = strconv.ParseInt(s2,10,64)
	fmt.Printf("num1的类型:%T,num1=%v \n",num1,num1)

	//string --> float32/float64
	var s3 string = "3.14"
	var f1 float64
	f1,_=strconv.ParseFloat(s3,64)
	fmt.Printf("f1的类型是:%T,f1=%v \n",f1,f1)

	//ps:string向基本数据类型转换时，一定要确保string类型能够转换为有效的数据类型
	//   否则最后得到的结果就是该类型的默认值
    var s4 string = "golang"
	var b1 bool
	b1,_=strconv.ParseBool(s4)
	fmt.Printf("b1的类型是:%T,b1=%v \n",b1,b1)
 } */

 //指针
/* func main(){
	var age int = 18
	//&符号+变量 可以获取到这个变量内存的地址
	fmt.Println(&age) //0xc00000e098
} */
//指针变量
func main(){
	/* var age int = 18
	fmt.Println(&age)
	//定义一个指针变量
	//var - 声明一个变量
	//ptr - 指针变量的名字
	//ptr对应的类型：*int 是一个指针类型 指向int的指针
	//&age是一个地址，是ptr变量具体的值
	var ptr *int = &age
	fmt.Println(ptr)
	fmt.Println("ptr本身这个存储空间的地址为：",&ptr) //0xc00000a030
	//获取ptr指针/地址所指向的具体数据
	fmt.Printf("ptr指向的数值为：%v",*ptr) //18 */
	//通过指针改变指向值
	var num int = 10
	fmt.Println(num)
	var ptr *int = &num
	*ptr = 20
	fmt.Println(num)
}